home *** CD-ROM | disk | FTP | other *** search
/ START Magazine / START VOL 4 NO 1.st / FSEARCH.ARC / FSEARCH.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-11-20  |  71.0 KB  |  2,264 lines
  1. /*-------------------------------------------------------------------*/
  2. /*                    "F I L E   S E A R C H"                        */
  3. /*                                                                   */
  4. /* by David T. Jarvis                                                */
  5. /* Copyright 1989 Antic Publishing                                   */
  6. /*                                                                   */
  7. /* FSEARCH.C                                                         */
  8. /* Version 051189                              */
  9. /*                                      */
  10. /* File Search is a desk accessory that allows users to search for   */
  11. /* files anywhere on a disk.  Once found, useful information about   */
  12. /* each file is displayed and various operations may be performed on */
  13. /* the file, including browsing it or copying it.  A list of all     */
  14. /* files found in a search may be displayed in a window or printed   */
  15. /* after the search has completed, and information about any of      */
  16. /* the files found may be redisplayed by double-clicking on the file */ 
  17. /* name in the list window.                                          */
  18. /*                                                                   */
  19. /* Developed With Mark Williams C                                    */
  20. /* Compile instructions:                                             */
  21. /*        cc -o fsearch.acc -VGEMACC fsearch.c                       */
  22. /* NOTE:  crtsd.s should be edited to increase the stack size from   */
  23. /* 1024 words to 4096, then reassembled with the command:            */
  24. /*        as -o crtsd.o crtsd.s                                      */
  25. /*-------------------------------------------------------------------*/
  26.  
  27. /* ---------- Includes and definitions ------------------------------*/
  28.  
  29. #include <stdio.h>         /* Standard I/O definitions               */
  30. #include <osbind.h>        /* Operating System bindings              */
  31. #include <xbios.h>         /* For Extended BIOS functions            */
  32. #include <gemdefs.h>       /* GEM structures and definitions         */
  33. #include <obdefs.h>        /* Object definitions                     */
  34. #include <vdibind.h>       /* VDI bindings                           */
  35. #include <aesbind.h>       /* AES bindings                           */
  36. #include <ctype.h>         /* character macros                       */
  37. #include "fsearch.h"       /* for resource index definitions         */
  38.  
  39. #define NO_WINDOW          -1
  40. #define NOT_SELECTED       -1
  41. #define NUMLINES           20
  42. #define LINEWIDTH          76
  43. #define OUTWIDTH           70
  44. #define MAXLINES         2000
  45. #define BUFSIZE          1024
  46. #define MAXSPEC           100
  47. #define ALLOCNUM       0x0064
  48. #define WINX               40
  49. #define WINY               20
  50. #define WTYPE  (NAME|CLOSER|SIZER|MOVER|INFO|UPARROW|DNARROW|VSLIDE|FULLER)
  51. #define BWTYPE (NAME|CLOSER|SIZER|MOVER|INFO|VSLIDE|FULLER)
  52. #define SATTR  (AT_RDO|AT_HID|AT_SYS|AT_DIR)
  53. #define DATTR  (AT_DIR|AT_SYS)
  54.  
  55. /* bit masks for directory attributes */
  56. #define AT_RDO    0x01     /* read-only                              */
  57. #define AT_HID    0x02     /* hidden file                            */
  58. #define AT_SYS    0x04     /* system file                            */
  59. #define AT_VOL    0x08     /* volume label                           */
  60. #define AT_DIR    0x10     /* directory, Also Known As "folder"      */
  61. #define AT_ARC    0x20     /* archival purposes                      */
  62.  
  63. /* Some portability definitions */
  64. #define BYTE    char
  65. #define WORD    int
  66. #define LONG    long
  67. #define TRUE    1
  68. #define FALSE   0
  69.  
  70. /* ------ Data Structures --------------------------------------------- */
  71.  
  72. typedef struct dta_str     /* Disk Transfer Address (DTA) structure     */
  73.    {
  74.    BYTE res[ 21 ];         /* reserved by TOS                           */
  75.    BYTE attr;              /* attribute byte                            */
  76.    WORD time;              /* time stamped on file                      */
  77.    WORD date;              /* date stamped on file                      */
  78.    LONG size;              /* size in bytes of file                     */
  79.    BYTE name[ 14 ];        /* filename, extension & terminating 0 (+1)  */
  80.    } DTA;
  81. typedef struct fl_str
  82.    {
  83.    struct fl_str *next;    /* In our Found file list will point to next */
  84.    BYTE attr;              /* attribute byte                            */
  85.    WORD time;              /* time stamped on file                      */
  86.    WORD date;              /* date stamped on file                      */
  87.    LONG size;              /* size in bytes of file                     */
  88.    BYTE spec[ MAXSPEC ];   /* complete file extension                   */
  89.    } FL;
  90. typedef struct bl_str
  91.    {
  92.    struct bl_str *next;    /* next allocated block of list members      */
  93.    struct fl_str *first;   /* first of ALLOCNUM entries                 */
  94.    } BL;
  95.  
  96. /* ---- Function declarations for functions in this program  ---------  */
  97.  
  98. BYTE *DJMalloc();     
  99. WORD HndlFound();
  100. WORD Browse();
  101. WORD DoCForm();
  102. WORD ValidSpec();           
  103. WORD AddList();
  104. WORD InitWindows();
  105. WORD ReDraw();
  106. WORD RefrText();
  107. WORD LoadFile();
  108. WORD RefrLine();
  109. WORD RefrEntry();
  110. WORD RefrBackground();
  111. WORD RefrList();
  112. WORD PrintList();
  113. WORD PrintLine();           
  114. WORD DoFile();              
  115. WORD copyfile();
  116. WORD movefile();
  117. WORD printfile();
  118. WORD delfile();
  119. WORD renamefile();
  120. WORD GetBack();
  121. WORD GetHeap();
  122. WORD BufToLine();
  123. WORD CalcSlidPos();
  124. WORD FinishFile();
  125. LONG Search();       
  126. void Init();
  127. void InitGEM();
  128. void AdjustResources();
  129. void ToHigh();
  130. void Interact();
  131. void StartForm();
  132. void OpenWork();     
  133. void DoSearch();     
  134. void EndSearch();    
  135. void FreeBlocks();   
  136. void FreeHeap();     
  137. void Select();
  138. void DeSelect();
  139. void SetSlidSize();
  140. void CalcRange();
  141. void CalcStart();
  142. void AsgnText();
  143. void BeginWait();
  144. void EndWait();
  145. void CloseCBox();
  146. void FmtTime();
  147. void FmtDate();
  148. void LineUp();
  149. void LineDown();
  150. void main();
  151.  
  152. /* ----- More function defs ---- Functions external to this module ---- */
  153. BYTE *strpbrk();
  154.  
  155. /* --------- Miscellaneous Global Variables --------------------------- */
  156.  
  157. BYTE filespec[ MAXSPEC ];  /* search filespec (default: *.*)            */
  158. BYTE fullname[ MAXSPEC ];  /* full file specification of found file     */
  159. BYTE alert_box[255];       /* For creation of form_alert strings        */
  160. BYTE title[] = "  File Search";     /* Accessory title                  */
  161. BYTE consearch[] = "Continue Search"; /* button text for f_form[]       */
  162. BYTE drv_let;              /* Letter of selected disk drive for search  */
  163. BYTE wind_name[ MAXSPEC ], wind_desc[ 81 ]; /* browse window stuff      */
  164. BYTE *pagetext[ MAXLINES ];      /* browse window text pointers         */
  165. BYTE *djheap, *heap_ptr;      /* Memory allocation for browse window    */
  166. WORD gl_apid, menu_id;     /* desk accessory ID variables               */
  167. WORD display_on;           /* 1 if matches are to be displayed, else 0  */
  168. WORD waiting;              /* 1 if a "wait" box is onscreen             */
  169. WORD filez;                /* number of files found on each search      */
  170. WORD foldz;                /* Number of folders searched on each search */
  171. WORD cur_drv;              /* number for current drive (A=0,B=1,etc)    */
  172. WORD last_path;            /* 0 or index in filespec of last \          */
  173. WORD num_lines, l_start, l_end, l_range, page_size;   /* browse stuff   */
  174. WORD slidpos, slidsize, newslid; /* browse window sliders               */
  175. WORD left_in_block = 0;    /* number of available file entry slots      */
  176. WORD mfdb[10];             /* I quote:  "fake" raster block             */
  177. WORD bw_handle;            /* Background window handle                  */
  178. WORD x_mx,y_mx,w_mx,h_mx,bx_wk,by_wk,bw_wk,bh_wk; /* window dimensions  */
  179. WORD browsing;             /* TRUE if browse window opened, 0 if not    */
  180. WORD memerror;             /* TRUE if couldn't keep all files in mem.   */
  181. WORD contrl[12],                 /* Global GEM variables                */
  182.      intin[256], intout[256],
  183.      ptsin[256], ptsout[256],
  184.      work_in[20], work_out[100],
  185.      handle;                     /* Screen handle                       */
  186. WORD msgbuf[ 8 ];                /* AES message buffer                  */
  187. WORD gr_x, gr_y, gr_w, gr_h;     /* Workstation dimensions              */
  188. WORD cwidth, cheight;            /* Current character cell height,width */
  189. WORD wret;                 /* Junk variable -- global to save stack     */
  190. WORD back_color = 3;       /* Background window color                   */
  191. LONG bytez;                /* total number of bytes per search          */
  192. LONG heap_avail = 0L;      /* Our program's "heap" bytes available      */
  193. GRECT waitbox, c_box;         /* GEM rectangles used globally        */
  194. DTA dta;                   /* Our program's Data Transfer Area          */
  195. FL *list_head;             /* will point to first in Found File list    */
  196. FL *next_file;             /* Next list member available in cur. block  */
  197. BL *cur_block=NULL, *block_head=NULL;               /* Allocated blocks */
  198.  
  199. /* ---------- GEM Resources for File Search --------------------------- */
  200. TEDINFO ted2[] = 
  201. {   "--------------------------------------------------",
  202.    "__________________________________________________",
  203.    "PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP",
  204.      3,  6,  0,0x1180,  0, -1, 51, 51
  205. };
  206. TEDINFO ted3[] = 
  207. {   "FILE SEARCH",
  208.    "",   "",
  209.      3,  6,  2,0x2103,  0,  2, 12,  1
  210. };
  211. TEDINFO ted4[] = 
  212. {   "File To Search For:",
  213.    "",   "",
  214.      3,  6,  0,0x1100,  0, -1, 20,  1
  215. };
  216. TEDINFO 
  217. ted5[] = 
  218. {   "Wilcards (? and *) Are Acceptable",
  219.    "",   "",
  220.      5,  6,  0,0x1100,  0, -1, 34,  1
  221. };
  222. TEDINFO ted8[] = 
  223. {   "Attributes:",
  224.    "",   "",
  225.      3,  6,  0,0x1200,  0, -1, 12,  1
  226. };
  227. TEDINFO ted9[] = 
  228. {   "Put Filename Herexxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  229.    "",   "",
  230.      3,  6,  0,0x1100,  0, -1, 56,  1
  231. };
  232. TEDINFO ted10[] = 
  233. {   "Bytesxxxxx",
  234.    "",   "",
  235.      3,  6,  0,0x1100,  0, -1, 11,  1
  236. };
  237. TEDINFO ted11[] = 
  238. {   "mmddyyyy",
  239.    "",   "",
  240.      3,  6,  0,0x1100,  0, -1,  9,  1
  241. };
  242. TEDINFO ted12[] = 
  243. {   "hh:mm:ss",
  244.    "",   "",
  245.      3,  6,  0,0x1100,  0, -1,  9,  1
  246. };
  247. TEDINFO ted13[] = 
  248. {   "Bytes :",
  249.    "",   "",
  250.      3,  6,  0,0x1200,  0, -1,  8,  1
  251. };
  252. TEDINFO ted14[] = 
  253. {   "Last Updated:",
  254.    "",   "",
  255.      3,  6,  0,0x1200,  0, -1, 14,  1
  256. };
  257. TEDINFO ted16[] = 
  258. {   "XXX",
  259.    "",   "",
  260.      3,  6,  0,0x1280,  0, -1,  4,  1
  261. };
  262. TEDINFO ted18[] = 
  263. {   "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
  264.    "",   "",
  265.      3,  6,  0,0x1280,  0, -1, 53,  1
  266. };
  267. TEDINFO ted19[] = 
  268. {   "FILE FOUND:",
  269.    "",   "",
  270.      3,  6,  0,0x21E3,  0, -1, 12,  1
  271. };
  272. TEDINFO ted20[] = 
  273. {   "File Name",
  274.    "",   "",
  275.      3,  6,  0,0x1200,  0, -1, 10,  1
  276. };
  277. TEDINFO ted24[] = 
  278. {   "Source Filexxxxxxxxxxxxxxxxxxxxxxxx:",
  279.    "",   "",
  280.      3,  6,  0,0x1100,  0, -1, 37,  1
  281. };
  282. TEDINFO ted25[] = 
  283. {   "Destinationxxxxxxxxxxxxxxxxxxxxxxx:",
  284.    "",   "",
  285.      3,  6,  0,0x1100,  0, -1, 36,  1
  286. };
  287. TEDINFO ted26[] = 
  288. {   "----------------------------------------",
  289.    "________________________________________",
  290.    "PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP",  /* only TOS filenames */
  291.      3,  6,  0,0x1180,  0, -1, 41, 41
  292. };
  293. TEDINFO ted27[] = 
  294. {   "----------------------------------------",
  295.    "________________________________________",
  296.    "PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP",
  297.      3,  6,  0,0x1180,  0, -1, 41, 41
  298. };
  299. TEDINFO ted28[] = 
  300. {   "File Copyxxxxxxxxxx",
  301.    "",   "",
  302.      3,  6,  2,0x2200,  0, -1, 20,  1
  303. };
  304. /* File Search dialog */
  305. OBJECT s_form[] = 
  306. {
  307.    {  -1,  1, 31,     G_BOX,  0, 16,  0xFC2143L, 72,  8,424, 136  },
  308.    {  19,  2, 18,    G_IBOX,  0,  0,    0x1100L,  6, 51,158,  56  },
  309.    {   3, -1, -1,  G_STRING,  0,  0,"Drive To Search:",  0,  3, 128,  8  },
  310.    {   4, -1, -1, G_BOXCHAR, 17,  0,0x41FF1100L, 16, 16, 32,  8  },
  311.    {   5, -1, -1, G_BOXCHAR, 17,  0,0x42FF1100L, 48, 16, 32,  8  },
  312.    {   6, -1, -1, G_BOXCHAR, 17,  0,0x43FF1100L, 80, 16, 32,  8  },
  313.    {   7, -1, -1, G_BOXCHAR, 17,  0,0x44FF1100L,112, 16, 32,  8  },
  314.    {   8, -1, -1, G_BOXCHAR, 17,  0,0x45FF1100L, 16, 25, 32,  8  },
  315.    {   9, -1, -1, G_BOXCHAR, 17,  0,0x46FF1100L, 48, 25, 32,  8  },
  316.    {  10, -1, -1, G_BOXCHAR, 17,  0,0x47FF1100L, 80, 25, 32,  8  },
  317.    {  11, -1, -1, G_BOXCHAR, 17,  0,0x48FF1100L,112, 25, 32,  8  },
  318.    {  12, -1, -1, G_BOXCHAR, 17,  0,0x4AFF1100L, 48, 34, 32,  8  },
  319.    {  13, -1, -1, G_BOXCHAR, 17,  0,0x4BFF1100L, 80, 34, 32,  8  },
  320.    {  14, -1, -1, G_BOXCHAR, 17,  0,0x4CFF1100L,112, 34, 32,  8  },
  321.    {  15, -1, -1, G_BOXCHAR, 17,  0,0x4DFF1100L, 16, 43, 32,  8  },
  322.    {  16, -1, -1, G_BOXCHAR, 17,  0,0x4EFF1100L, 48, 43, 32,  8  },
  323.    {  17, -1, -1, G_BOXCHAR, 17,  0,0x4FFF1100L, 80, 43, 32,  8  },
  324.    {  18, -1, -1, G_BOXCHAR, 17,  0,0x50FF1100L,112, 43, 32,  8  },
  325.    {   1, -1, -1, G_BOXCHAR, 17,  0,0x49FF1100L, 16, 34, 32,  8  },
  326.    {  20, -1, -1,   G_FTEXT,  9,  0,      ted2,  6, 43,400,  8  },
  327.    {  21, -1, -1, G_BOXTEXT,  5, 32,      ted3,  8,  8,400, 16  },
  328.    {  22, -1, -1,  G_STRING,  0,  0,"File To Search For:",  8, 32,152,  8  },
  329.    {  23, -1, -1,    G_TEXT,  0,  0,      ted5,210, 31,198,  8  },
  330.    {  24, -1, -1,  G_BUTTON,  7,  0,  "SEARCH",112,112, 88, 16  },
  331.    {  25, -1, -1,  G_BUTTON,  5,  0,"QUIT",216,112, 88, 16  },
  332.    {  29, 26, 28,    G_IBOX,  0,  0,0x1100L,155, 52,156, 60  },
  333.    {  27, -1, -1,  G_BUTTON, 17,  1,"Each Match", 29, 14, 99,  9  },
  334.    {  28, -1, -1,  G_STRING,  0,  0,   "Report:", 19,  2, 56,  8  },
  335.    {  25, -1, -1,  G_BUTTON, 17,  0,"Totals Only", 28, 28,100,  8  },
  336.    {  30, -1, -1,  G_STRING,  0,  0,"Files Found:",307, 54, 96,  8  },
  337.    {  31, -1, -1,  G_BUTTON,  5,  8,"Browse",      321, 67, 64,  8  },
  338.    {   0, -1, -1,  G_BUTTON, 37,  8,"Print",       322, 80, 64,  8  }
  339. };
  340. /* File Found Dialog */
  341. OBJECT f_form[] = 
  342. {
  343.    {  -1,  1, 25,     G_BOX,  0, 16, 0xFF21C3L, 64,  8,472,160  },
  344.    {  13,  2, 12,    G_IBOX,  0,  0,   0x1100L,  8, 24,448, 48  },
  345.    {   3, -1, -1,    G_TEXT,  0,  0,      ted8,   0, 12, 88,  8  },
  346.    {   4, -1, -1,  G_BUTTON,  0,  0,"Read-Only",  8, 23, 80,  8  },
  347.    {   5, -1, -1,  G_BUTTON,  0,  0,"Hidden",    88, 23, 80,  8  },
  348.    {   6, -1, -1,  G_BUTTON,  0,  0,"System",   168, 23, 80,  8  },
  349.    {   7, -1, -1,  G_BUTTON,  0,  0,"Volume",     8, 32, 80,  8  },
  350.    {   8, -1, -1,  G_BUTTON,  0,  0,"Folder",    88, 32, 80,  8  },
  351.    {   9, -1, -1,  G_BUTTON,  0,  0,"Archive",  168, 32, 80,  8  },
  352.    {  10, -1, -1,    G_TEXT,  0,  0,     ted9,    8,  2,440,  8  },
  353.    {  11, -1, -1,    G_TEXT,  0,  0,    ted10,  329, 33, 80,  8  },
  354.    {  12, -1, -1,    G_TEXT,  0,  0,    ted11,  280, 24, 64,  8  },
  355.    {   1, -1, -1,    G_TEXT,  0,  0,    ted12,  361, 24, 64,  8  },
  356.    {  14, -1, -1,    G_TEXT,  0,  0,    ted13,  269, 57, 56,  8  },
  357.    {  15, -1, -1,    G_TEXT,  0,  0,    ted14,  269, 37,104,  8  },
  358.    {  20, 16, 19,     G_BOX,  0, 32, 0x12113L,    8, 72,448, 32  },
  359.    {  17, -1, -1,  G_STRING,  0,  0,"Found So Far:",7, 21,104,  8  },
  360.    {  18, -1, -1,    G_TEXT,  0,  0,    ted16,  126, 22, 24,  8  },
  361.    {  19, -1, -1,  G_STRING,  0,  0,"File Search Specification Was:",
  362.                                                   5,  2,240,  8  },
  363.    {  15, -1, -1,    G_TEXT,  0,  0,    ted18,   21, 11,416,  8  },
  364.    {  21, -1, -1,  G_BUTTON,  7,  0,consearch,   16,144,136,  8  },
  365.    {  22, -1, -1,  G_BUTTON,  5,  0,"Quit",     384,144, 72,  8  },
  366.    {  23, -1, -1,  G_BUTTON,  5,  0,"Return To Search Menu",168,144,208,  8  },
  367.    {  24, -1, -1, G_BOXTEXT,  0, 32,    ted19,    8,  0, 88,  8  },
  368.    {  25, -1, -1,    G_TEXT,  0,  0,    ted20,    8, 16, 72,  8  },
  369.    {   0, 26, 33,     G_BOX,  0, 32,0xFF2113L,    8,112,448, 24  },
  370.    {  27, -1, -1,  G_STRING,  0,  0,"Function:",    6, 13, 72,  8  },
  371.    {  28, -1, -1,  G_BUTTON,  5,  0,"Browse",   104,  8, 56,  8  },
  372.    {  29, -1, -1,  G_BUTTON,  5,  0,"Rename",   168,  8, 56,  8  },
  373.    {  30, -1, -1,  G_BUTTON,  5,  0,"Copy",     232,  8, 48,  8  },
  374.    {  31, -1, -1,  G_BUTTON,  5,  0,"Delete",   336,  8, 48,  8  },
  375.    {  32, -1, -1,  G_BUTTON,  5,  0,"Move",     288,  8, 40,  8  },
  376.    {  33, -1, -1,  G_BUTTON,  5,  0,"Print",    392,  8, 48,  8  },
  377.    {  25, -1, -1,  G_STRING, 32,  0,   "TOS",    27,  4, 24,  8  }
  378. };
  379. /* "Searching..." form */
  380. OBJECT w_form[] = 
  381. {
  382.    {  -1,  1,  1,     G_BOX,  0, 48,0xFE2263L,120, 16,256, 40  },
  383.    {   0, -1, -1,  G_STRING, 32,  0,"Searching...", 16, 24, 96,  8  }
  384. };
  385. /* c_form[] gets information about two filespecs for copy, move, etc. */
  386. OBJECT c_form[] = 
  387. {
  388.    {  -1,  1,  7,     G_BOX,  0, 48,   0x12203L, 56,  8,352, 88  },
  389.    {   2, -1, -1,    G_TEXT,  0,  0,      ted24, 16, 24,288,  8  },
  390.    {   3, -1, -1,    G_TEXT,  0,  0,      ted25, 16, 48,280,  8  },
  391.    {   4, -1, -1,   G_FTEXT,  8,  0,      ted26, 16, 32,320,  8  },
  392.    {   5, -1, -1,   G_FTEXT,  9,  0,      ted27, 16, 56,320,  8  },
  393.    {   6, -1, -1, G_BOXTEXT,  0, 32,      ted28, 16,  8,320,  8  },
  394.    {   7, -1, -1,  G_BUTTON,  7,  0,       "OK", 72, 72, 64,  8  },
  395.    {   0, -1, -1,  G_BUTTON, 37,  0,   "CANCEL",216, 72, 64,  8  }
  396. };
  397. /* "Loading..." form */
  398. OBJECT l_form[] = 
  399. {
  400.    {  -1,  1,  2,     G_BOX,  0, 48, 0x12143L, 24,  8,248, 40  },
  401.    {   2, -1, -1,  G_STRING,  0,  0,"Loading...", 16,  8, 80,  8  },
  402.    {   0, -1, -1,     G_BOX, 32,  0,0xFF1101L, 16, 24,216,  8  }
  403. };
  404.  
  405. /* ------- form_alert() strings --------------------------------------- */
  406.  
  407. BYTE nomem[]     = "[1][ Error: | Not Enough Memory | For Browse ][ CANCEL ]";
  408. BYTE filerr[]    = "[1][ Error: | The File Could Not| Be Opened ][ CANCEL ]";
  409. BYTE crerror[]   = "[1][ Error: | File Creation Failed ][ CANCEL ]";
  410. BYTE badwrite[]  = "[3][ File Write Error: ][ Retry | CANCEL ]";
  411. BYTE badcopy[]   =
  412. "[1][ Destination Same As Source | Copy/Move Not Allowed ][ CANCEL ]";
  413. BYTE movexist[]  =
  414. "[1][ You May Not | Move A File To | An Existing File ][ CANCEL ]";
  415. BYTE notfound[] =
  416. "[0][ No Files Were Found | Matching That Specification. ][ Thanks | Repeat ]";
  417. BYTE delerror[] =
  418. "[1][ An Error Occurred When | Attempting To Delete The File ][ OK ]";
  419. BYTE suredel[] =
  420. "[2][ Are You SURE | You Want To Delete | The File? ][ YES | CANCEL ]";
  421. BYTE badrename[] = "[1][ The Rename Operation Failed ][ OK ]";
  422. BYTE copywarn[] =
  423. "[1][ WARNING:  Destination File | Will Be Overwritten ][ OK | CANCEL ]";
  424. BYTE no_windows[] = "[1][ No Windows Available ][ CANCEL ]";
  425. BYTE prnerror[] = "[1][ The Printer Is Not Responding ][ Retry | CANCEL ]";
  426. BYTE badspec[] =
  427. "[1][ You Have Entered | An Invalid | File Specification ][ CANCEL ]";
  428. BYTE badname[] =
  429. "[1][ File Specification | Contains An Invalid | File/Folder Name ][ CANCEL ]";
  430. BYTE badext[] =
  431. "[1][ File Specification | Has An Invalid | File/Folder Extension ][ CANCEL ]";
  432. BYTE badwild[] =
  433. "[1][ Wildcards | Are Not Supported | Within Folder Names ][ Re-Enter ]";
  434. BYTE baddrive[] = "[1][ You Have Selected | An Invalid Drive ][ CANCEL ]";
  435. BYTE BadAdd[] =
  436. "[0][ WARNING: | Insufficient Memory | To Keep All | Files In List ][ Go On ]";
  437. BYTE whodunit[] =
  438. "[0][         File Search         |     by David T. Jarvis     |\
  439. Copyright 1989 Antic Publishing, Inc.\
  440. ][ Yeah! ]";
  441.  
  442.  
  443. /* --------- Main function --------------------------------------------- */
  444.  
  445. void main()
  446. {
  447. /* Initialize everything */
  448.    Init();
  449. /* handle interaction with GEM and the user */
  450.    Interact();
  451. }
  452.  
  453. /* -------- Initialization functions ---------------------------------- */
  454.  
  455. void Init()
  456. {
  457.    InitGEM();
  458.    browsing = FALSE;
  459.    s_form[ SDRIVEA+(WORD)Dgetdrv() ].ob_state |= SELECTED;
  460.    AsgnText( s_form,SFILE,filespec );
  461.    filespec[ 0 ] = '\0';
  462.    mfdb[0] = mfdb[1] = 0;
  463.    AdjustResources();
  464.    /* Install desk accessory */
  465.    menu_id = menu_register( gl_apid,title );
  466. }
  467.  
  468. void InitGEM()
  469. {
  470. /* Initialize GEM application */
  471.    gl_apid = appl_init();
  472.    handle = graf_handle( &gr_x,&gr_y,&gr_w,&gr_h );
  473. }
  474.  
  475. /* AdjustResources() checks for high resolution and adjusts the 
  476.    resource offsets accordingly if it is being used */
  477. void AdjustResources()
  478. {
  479.    if (Getrez()==2)            /* high resolution */
  480.       {
  481.       ToHigh( s_form,32 );
  482.       ToHigh( f_form,34 );
  483.       ToHigh( c_form,8 );
  484.       ToHigh( l_form,3 );
  485.       ToHigh( w_form,2 );  
  486.       back_color = 0;         /* white background if in monochrome */
  487.       }
  488. }
  489.  
  490. void ToHigh( form,num )
  491. OBJECT form[];
  492. WORD num;
  493. {
  494. register WORD i;
  495.  
  496.    for (i=0; i<num; i++)
  497.       {
  498.       form[ i ].ob_y *= 2;
  499.       form[ i ].ob_height *= 2;
  500.       }
  501. }
  502.  
  503. WORD InitWindows()
  504. {
  505. /* Set maximum size of all windows to desktop size */
  506.    wind_get(0,4,&x_mx,&y_mx,&w_mx,&h_mx);
  507.  
  508. /* Calculate working area for background window using size it'll be opened as */
  509.    wind_calc(1,0,x_mx,y_mx,w_mx,h_mx,
  510.              &bx_wk,&by_wk,&bw_wk,&bh_wk);
  511.  
  512. /* Create the big background window */
  513.    if ((bw_handle = wind_create( 0,x_mx,y_mx,w_mx,h_mx )) < 0)
  514.       {
  515.       form_alert(1,no_windows);
  516.       return(-1);
  517.       }
  518.    return( 0 );
  519. }
  520.  
  521. void OpenWork()
  522. {
  523. WORD attrib[ 10 ];
  524. register WORD i;
  525.  
  526.    for (i=0; i < 10; i++)
  527.       work_in[ i ] = 1;
  528.    work_in[ 10 ] = 2;
  529.    v_opnvwk( work_in,&handle,work_out );
  530.    vqt_attributes( handle,attrib );
  531.    cwidth = attrib[ 8 ];      cheight = attrib[ 9 ];
  532. }
  533.  
  534. /* ----------- Interact() -- drives the desk accessory -------------- */
  535. void Interact()
  536. {
  537. WORD event, clik_x, clik_y, num_cliks, bstate, kstate, keycode;
  538.  
  539.    /* Infinitely check for messages related to this accessory */
  540.    while (TRUE)
  541.       {
  542.       event = evnt_multi(MU_MESAG,0,0,0,
  543.                          0,0,0,0,0,
  544.                          0,0,0,0,0,
  545.                          msgbuf,0,0,
  546.                          &clik_x,&clik_y,&bstate,
  547.                          &kstate,&keycode,&num_cliks );
  548.  
  549.       /* If the user clicked on the accessory name, run */
  550.       if (event & MU_MESAG)
  551.          {
  552.          switch( msgbuf[0] )
  553.             {
  554.             case AC_OPEN:
  555.                if (msgbuf[4] == menu_id)
  556.                   {
  557.                   OpenWork();
  558.                   DoSearch();
  559.                   v_clsvwk( handle );
  560.                   }
  561.                break;
  562.             default:
  563.                break;
  564.             }
  565.          }
  566.       }  /* end while loop */
  567. }
  568.  
  569. /* --------------------------------------------------------------------- */
  570. /*    DoSearch() inputs the search criteria, performs the searches, and  */
  571. /*    reports the results                         */
  572. /* --------------------------------------------------------------------  */
  573. void DoSearch()
  574. {
  575. BYTE startdir[ MAXSPEC ];
  576. WORD clip[4], retry;
  577. register WORD button, i;
  578. register LONG drives, bittest, ret = 0L;
  579. GRECT box;
  580.  
  581.    /* Put current system values into the search form */
  582.    drives = Drvmap();
  583.    for (bittest = 1L,i = 0; i<16; bittest *= 2L,i++)
  584.       {
  585.       if ((WORD)(bittest & drives))
  586.          s_form[ SDRIVEA+i ].ob_state &= ~DISABLED;
  587.       else
  588.          {
  589.          s_form[ SDRIVEA+i ].ob_state = DISABLED;
  590.          s_form[ SDRIVEA+i ].ob_state &= ~SELECTED;
  591.          }
  592.       }
  593.    s_form[ SBROWSE ].ob_state = DISABLED;
  594.    s_form[ SPRINT ].ob_state = DISABLED;
  595.  
  596.    /* Open & clear a window enclosing the entire desktop */
  597.    if (InitWindows())
  598.       return;
  599.    wind_open( bw_handle,x_mx,y_mx,w_mx,h_mx );
  600.    graf_mouse( M_OFF,0 );
  601.    clip[0] = bx_wk;        clip[1] = by_wk;
  602.    clip[2] = bw_wk;        clip[3] = bh_wk + cheight + 2;
  603.    vs_clip( handle,1,clip );
  604.    vsf_interior( handle,2 );
  605.    vsf_style( handle,8 );
  606.    vsf_color( handle,3 );
  607.    v_bar( handle,clip );
  608.    graf_mouse( M_ON,0 );
  609.  
  610.    while (TRUE)
  611.       {
  612.       /* Display the search criteria input form */
  613.       StartForm( s_form,&box,2,1,1 );
  614.  
  615.       /* Let the user take over */
  616.       button = form_do( s_form,SFILE );
  617.  
  618.       /* Remove the form and restore altered states */
  619.       s_form[ button ].ob_state &= ~SELECTED;
  620.       form_dial( FMD_SHRINK,0,0,0,0,
  621.                  box.g_x,box.g_y,box.g_w,box.g_h );
  622.       form_dial( FMD_FINISH,0,0,0,0,box.g_x,box.g_y,box.g_w,box.g_h );
  623.  
  624.       /* Check which button the user pressed */
  625.       switch( button )
  626.          {
  627.          /* If they clicked on the title, time to point fingers */
  628.          case 20:
  629.             form_alert( 1,whodunit );
  630.             break;
  631.          /* If the user is finished, clean up and go */
  632.          case SCANCEL:
  633.             wind_close( bw_handle );
  634.             wind_delete( bw_handle );
  635.             FreeBlocks();
  636.             return;
  637.             break;
  638.          case SBROWSE:
  639.             Browse( filespec,0 );
  640.             break;
  641.          case SPRINT:
  642.             PrintList();
  643.             break;
  644.          default:
  645.             /* Validate the file spec -- if necessary, perform some
  646.                formatting on it & select the disk drive */
  647.             if (ValidSpec( filespec )==FALSE)
  648.                break;
  649.             /* Determine whether to display each file match or not */
  650.             display_on = (s_form[ SALL ].ob_state & SELECTED) ? 1 : 0;
  651.  
  652.             /* Initialize search variables */
  653.             FreeBlocks();
  654.             startdir[ 0 ] = drv_let;
  655.             startdir[ 1 ] = ':';
  656.             startdir[ 2 ] = '\0';
  657.             if (last_path)
  658.                {
  659.                strncat( startdir,filespec,last_path );
  660.                startdir[ last_path+2 ] = '\0';
  661.                }
  662.             filez = foldz = 0;           bytez = 0L;
  663.             memerror = FALSE;
  664.  
  665.             /* Recursively search all directories for matches */
  666.             do
  667.                {
  668.                retry = 0;
  669.                if (last_path)
  670.                   ret = Search( startdir,filespec+last_path );
  671.                else
  672.                   ret = Search( startdir,filespec );
  673.                if (ret == -2L)
  674.                   {
  675.                   wind_close( bw_handle );
  676.                   wind_delete( bw_handle );
  677.                   FreeBlocks();
  678.                   return;
  679.                   }
  680.                if (!filez)
  681.                   retry = form_alert( 1,notfound );
  682.                else
  683.                   if (ret > 1L)
  684.                      EndSearch( filez,drv_let );
  685.                if (memerror)
  686.                   form_alert( 1,BadAdd );
  687.                } while (retry == 2);
  688.             ReDraw( bw_handle,bx_wk,by_wk,bw_wk,bh_wk,0 );
  689.             break;
  690.          }  /* end, switch */
  691.       }  /* while TRUE */
  692. }
  693.  
  694. /* --------------------------------------------------------------------- */
  695. /* HndlFound() is invoked, if the user has requested that each match     */
  696. /* be reported, after a match is found on the current search.  It uses   */
  697. /* the "found" dialog (f_form) to display information about the file and */
  698. /* offers the user several choices for the next action: continue the     */
  699. /* current search, start a new search, exit from the accessory or        */
  700. /* perform one of the following file operations on the found file:       */
  701. /* copy, move, delete, rename, browse, or print.                         */
  702. /* This function may also be invoked when the user selects, with the     */
  703. /* mouse, a file from the list of files found in the last search.  If    */
  704. /* this is the case, the fromlist argument will equal one.               */
  705. /* --------------------------------------------------------------------- */
  706. WORD HndlFound( dtaptr,fullname,files,fromlist )
  707. DTA *dtaptr;
  708. BYTE *fullname;
  709. WORD files, fromlist;
  710. {
  711. register BYTE bittest;
  712. BYTE dbuff[ 11 ], tbuff[ 11 ], bbuff[ 11 ], fbuff[ 4 ];
  713. register WORD button, i;
  714. GRECT box;
  715.  
  716.    /* Copy the file information onto the form */
  717.    AsgnText( f_form,FFILE,fullname );
  718.    AsgnText( f_form,FSPEC,filespec );
  719.    FmtTime( dtaptr->time,tbuff );
  720.    FmtDate( dtaptr->date,dbuff );
  721.    sprintf( bbuff,"%8lu",dtaptr->size );
  722.    AsgnText( f_form,FTIME,tbuff );
  723.    AsgnText( f_form,FDATE,dbuff );
  724.    AsgnText( f_form,FBYTES,bbuff );
  725.    for (bittest = 1, i = 0; bittest < 32; bittest *= 2,i++)
  726.       if (dtaptr->attr & bittest)
  727.          f_form[ FREADONL+i ].ob_state = SELECTED;
  728.       else
  729.          f_form[ FREADONL+i ].ob_state = DISABLED;
  730.    sprintf( fbuff,"%d",files );
  731.    AsgnText( f_form,FMATCHES,fbuff );
  732.  
  733.    /* if necessary, clear the "waiting" box */
  734.    if (waiting)
  735.       EndWait();
  736.  
  737.    /* For files, enable the file manipulation options;  for folders, disable */
  738.    if (dtaptr->attr & AT_DIR)
  739.       for (i=FBROWSE; i<=FPRINT; i++)
  740.          f_form[ i ].ob_state |= DISABLED;
  741.    else
  742.       for (i=FBROWSE; i<=FPRINT; i++)
  743.          f_form[ i ].ob_state &= ~DISABLED;
  744.    /* Most TOS file ops are not supported for a file selected from the list */
  745.    if (fromlist)
  746.       for (i=FBROWSE; i<FPRINT; i++)
  747.          f_form[ i ].ob_state |= DISABLED;
  748.  
  749.    /* Get the form started on screen */
  750.    StartForm( f_form,&box,2,0,0 );
  751.  
  752.    /* Let the user handle the form */
  753.    while (1)
  754.       {
  755.       objc_draw( f_form,0,2,box.g_x,box.g_y,box.g_w,box.g_h );
  756.       button = form_do( f_form,0 );
  757.       f_form[ button ].ob_state &= ~SELECTED;
  758.       objc_change(f_form,button,0,box.g_x,box.g_y,box.g_w,box.g_h,NORMAL,1);
  759.       /* handle TOS functions here */
  760.       switch( button )
  761.          {
  762.          case FBROWSE:     Browse( fullname,1 );
  763.                            break;
  764.          case FRENAME:     renamefile( fullname );
  765.                            break;
  766.          case FCOPY:       copyfile( fullname );
  767.                            break;
  768.          case FMOVE:       movefile( fullname );
  769.                            break;
  770.          case FDELETE:     if (!delfile( fullname ))
  771.                               for (i=FBROWSE; i<=FPRINT; i++)
  772.                                  f_form[ i ].ob_state |= DISABLED;
  773.                            break;
  774.          case FPRINT:      printfile( fullname );
  775.                            break;
  776.          default:
  777.             /* Remove the form and restore altered states */
  778.             form_dial( FMD_FINISH,0,0,0,0,box.g_x,box.g_y,box.g_w,box.g_h );
  779.             /* Let the calling function handle other choices */
  780.             return( button );
  781.          }     /* end, switch */
  782.       }     /* end, while */
  783. }
  784.  
  785. /* --------------------------------------------------------------------- */
  786. /* DoFile() lets the user examine information and perform operations on  */
  787. /* a file which was found in the last search.  The file has been         */
  788. /* selected from the Browse() window.                                    */
  789. /* --------------------------------------------------------------------- */
  790. WORD DoFile( which )
  791. WORD which;
  792. {
  793. register WORD i;
  794. register FL *next;
  795. DTA dta2;
  796.  
  797.    /* find the entry */
  798.    next = list_head;
  799.    for (i=0; i<which; i++)
  800.       {
  801.       if (next == NULL)
  802.          return( -1 );
  803.       next = next->next;
  804.       }
  805.    /* set up the "fake" DTA */
  806.    strcpy( dta2.name,"Listed" );
  807.    dta2.size = next->size;
  808.    dta2.time = next->time;
  809.    dta2.date = next->date;
  810.    dta2.attr = next->attr;
  811.    /* Modify the found file dialog slightly */
  812.    f_form[ FNEXT ].ob_spec = (LONG)"Return To List";
  813.    f_form[ FDONE ].ob_state |= DISABLED;
  814.    f_form[ FANOTHER ].ob_state |= DISABLED;
  815.    /* display the file information */
  816.    HndlFound( &dta2,next->spec,filez,1 );
  817.    /* Get the form back to normal */
  818.    f_form[ FNEXT ].ob_spec = (LONG)consearch;
  819.    f_form[ FDONE ].ob_state &= ~DISABLED;
  820.    f_form[ FANOTHER ].ob_state &= ~DISABLED;
  821.    return(0);
  822. }
  823.  
  824. /* --------- Miscellanous GEM utility functions ------------------- */
  825.  
  826. WORD DoCForm( workfile,dest,flag )
  827. BYTE workfile[],dest[];
  828. WORD flag;
  829. {
  830. register WORD button;
  831.  
  832.    switch( flag )
  833.       {
  834.       case 0:
  835.          AsgnText( c_form,CTITLE,"File Rename" );
  836.          AsgnText( c_form,CT1,"Current Name:" );
  837.          AsgnText( c_form,CT2,"New Name:" );
  838.          break;
  839.       case 1:
  840.          AsgnText( c_form,CTITLE,"File Copy" );
  841.          AsgnText( c_form,CT1,"Source File:" );
  842.          AsgnText( c_form,CT2,"Destination File:" );
  843.          break;
  844.       case 2:
  845.          AsgnText( c_form,CTITLE,"File Move" );
  846.          AsgnText( c_form,CT1,"Source File:" );
  847.          AsgnText( c_form,CT2,"Destination File:" );
  848.          break;
  849.       default:
  850.          break;
  851.       }     /* end switch */
  852.    c_form[ CT1 ].ob_flags &= ~EDITABLE;
  853.  
  854.    /* Set the form to point to the source and destination strings */
  855.    AsgnText( c_form,CSOURCE,workfile );
  856.    AsgnText( c_form,CDEST,dest );
  857.    dest[ 0 ] = '\0';
  858.  
  859.    /* Put up the form */
  860.    StartForm( c_form,&c_box,2,0,1 );
  861.  
  862.    /* Let the user take over */
  863.    button = form_do( c_form,CDEST );
  864.  
  865.    /* Remove the form and restore altered states */
  866.    c_form[ button ].ob_state &= ~SELECTED;
  867.    objc_change( c_form,button,0,c_box.g_x,c_box.g_y,c_box.g_w,c_box.g_h,
  868.                 NORMAL,1 );
  869.  
  870.    /* If the user changed their mind, exit */
  871.    if (button == CCANCEL)
  872.       return(-1);
  873.    /* Otherwise, make sure both file names are complete */
  874.    FinishFile( workfile );
  875.    FinishFile( dest );
  876.    return( 0 );
  877. }
  878.  
  879. void CloseCBox()
  880. {
  881.    form_dial( FMD_FINISH,0,0,0,0,c_box.g_x,c_box.g_y,c_box.g_w,c_box.g_h );
  882. }
  883.  
  884. void EndSearch( count,drive )
  885. WORD count;
  886. BYTE drive;
  887. {
  888. BYTE temp[ 81 ];
  889.  
  890.     sprintf( alert_box,
  891.                  "[0][ Search Completed On Drive %c | With %d Match(es) | ",
  892.                  drive,count );
  893.         sprintf( temp,"Comprising %lu Byte(s). | ",bytez );
  894.         strcat( alert_box,temp );
  895.         sprintf( temp,"%d Folder(s) Searched. ][ Great! ]",foldz );
  896.         strcat( alert_box,temp );
  897.     form_alert( 1,alert_box );
  898. }
  899.  
  900. /* AsgnText() -- assign a string to a TEDINFO structure */
  901. /* Or, TEDINFO's excellent adventure ?... */
  902. void AsgnText( form,field,string )
  903. OBJECT *form;
  904. WORD field;
  905. BYTE string[];
  906. {
  907. register TEDINFO *ted_ptr; 
  908.  
  909.    ted_ptr = (TEDINFO *)form[ field ].ob_spec;
  910.    ted_ptr->te_ptext = (unsigned BYTE *)string;
  911. }
  912.  
  913. void StartForm( form,box,level,flag1,flag2 )
  914. OBJECT *form;
  915. GRECT *box;
  916. WORD level,flag1,flag2;
  917. {
  918.    form_center( form,&(box->g_x),&(box->g_y),
  919.                 &(box->g_w),&(box->g_h) );
  920.    form_dial( FMD_START,0,0,0,0,
  921.               box->g_x,box->g_y,box->g_w,box->g_h );
  922.    if (flag1)
  923.       form_dial( FMD_GROW,0,0,0,0,box->g_x,box->g_y,box->g_w,box->g_h );
  924.    if (flag2)
  925.       objc_draw( form,0,level,box->g_x,box->g_y,box->g_w,box->g_h );
  926. }
  927.  
  928. /* BeginWait() and EndWait() enable and disable, respectively, the
  929.    appearance of the "Searching..." box on the screen while 
  930.    a new directory is being searched
  931. */
  932. void BeginWait()
  933. {
  934.    StartForm( w_form,&waitbox,2,0,1 );
  935.    waiting = 1;
  936. }
  937.  
  938. void EndWait()
  939. {
  940.    form_dial( FMD_FINISH,0,0,0,0,waitbox.g_x,waitbox.g_y,
  941.               waitbox.g_w,waitbox.g_h );
  942.    waiting = 0;
  943. }
  944.  
  945. /* -------- Search() -- the recursive search routine called from DoSearch() */
  946.  
  947. LONG Search( s,m )
  948. BYTE s[], m[];
  949. {
  950. BYTE news[ MAXSPEC ];            /* new search string */
  951. BYTE dsearch[ MAXSPEC ];         /* directory search string */
  952. BYTE save[ MAXSPEC ];            /* where we were before */
  953. register LONG ret;               /* return code, call to self */
  954. register LONG f_count = 0L;      /* count of matches */
  955. register LONG flags = 0L;        /* return value of BIOS functions */
  956. register DTA *olddta;            /* save this and restore at end */
  957.  
  958.    /* Every call to Search() searches another folder (or the root) */
  959.    foldz++;
  960.  
  961.    /* build search string */
  962.    strcpy( news,s );
  963.    if (m[0] != '\\')
  964.       strcat( news,"\\" );
  965.    strcat( news,m );
  966.  
  967.    /* Set Disk Transfer Address, saving old one */
  968.    olddta = (struct dta_str *)Fgetdta();
  969.    Fsetdta( &dta );
  970.  
  971.    /* Find first matching file */
  972.    flags = Fsfirst( news,SATTR );
  973.  
  974.    /* As long as matches exist, find NEXT matching file */
  975.    while (!flags)
  976.       {
  977.       /* Is this a directory? */
  978.       if (dta.name[0] == '.')
  979.          {
  980.          flags = Fsnext();
  981.          continue;
  982.          }
  983.       /* Build the full name of the file */
  984.       strcpy( fullname,s );
  985.       strcat( fullname,"\\" );
  986.       strcat( fullname,dta.name );
  987.       /* Increase file counts, byte counts */
  988.       f_count++;
  989.       filez++;
  990.       bytez += dta.size;
  991.       /* If all matches are to be reported, report & handle */ 
  992.       if (display_on)
  993.          wret = HndlFound( &dta,fullname,filez,0 );
  994.       /* Add this file's info to the list in memory */
  995.       if (AddList( &dta,fullname ))
  996.          memerror = TRUE;
  997.       else
  998.          {
  999.          /* Files found -- enable browse & print list options */
  1000.          s_form[ SBROWSE ].ob_state &= ~DISABLED;
  1001.          s_form[ SPRINT ].ob_state  &= ~DISABLED;
  1002.          }
  1003.       /* Take next action depending on what user selected */
  1004.       if (display_on)
  1005.          switch( wret )
  1006.             {
  1007.             case FANOTHER: Fsetdta( olddta ); return( -1L );
  1008.             case FDONE:    Fsetdta( olddta ); return( -2L );
  1009.             default:       break;
  1010.             }        /* end, switch */
  1011.       flags = Fsnext();
  1012.       }
  1013.  
  1014.    /* Now, search for subdirectories -- find FIRST */
  1015.    strcpy( dsearch,s );
  1016.    strcat( dsearch,"\\*.*" );
  1017.    flags = Fsfirst( dsearch,(WORD)DATTR );
  1018.  
  1019.    /* Search each directory found for matching files */
  1020.    while (!flags)
  1021.       {
  1022.       if ((dta.attr & AT_DIR)&&(dta.name[ 0 ] != '.'))
  1023.          {
  1024.          if (!waiting)
  1025.             BeginWait();
  1026.          strcpy( news,s );
  1027.          strcat( news,"\\" );
  1028.          strcat( news,dta.name );
  1029.          strcpy( save,dta.name );
  1030.          ret = Search( news,m );
  1031.          if (ret < 0L)
  1032.             {
  1033.             Fsetdta( olddta );
  1034.             return( ret );
  1035.             }
  1036.          else
  1037.             f_count += ret;
  1038.          GetBack( dsearch,save );
  1039.          }
  1040.       flags = Fsnext();
  1041.       }
  1042.    /* Restore old DTA */
  1043.    Fsetdta( olddta );
  1044.  
  1045.    /* Return number of matches, this directory */
  1046.    return( f_count );
  1047. }
  1048.  
  1049. /* GetBack() returns to us to the previous directory position */
  1050. WORD GetBack( s,m )
  1051. BYTE s[], m[];
  1052. {
  1053. register LONG flags;
  1054.  
  1055.    flags = Fsfirst( s,(WORD)DATTR );
  1056.    while ((!flags)&&(strcmp( dta.name,m )))
  1057.       flags = Fsnext();
  1058.    return(0);
  1059. }
  1060.  
  1061. /* ------------- File manipulation functions ------------------------ */
  1062.  
  1063. WORD copyfile( workfile )
  1064. BYTE workfile[];
  1065. {
  1066. BYTE destfile[ MAXSPEC ], buffer[ BUFSIZE ];
  1067. register WORD fh1, fh2;
  1068. register LONG lret;
  1069.  
  1070.    if ((DoCForm( workfile,destfile,1 ))||!strlen( destfile ))
  1071.       {
  1072.       CloseCBox();
  1073.       return(0);
  1074.       }
  1075.    if (strcmp( workfile,destfile )==0)
  1076.       {
  1077.       form_alert( 1,badcopy );
  1078.       CloseCBox();
  1079.       return( -1 );
  1080.       }
  1081.    if ((fh1 = Fopen( workfile,0 )) < 0)
  1082.       {
  1083.       form_alert( 1,filerr );
  1084.       CloseCBox();
  1085.       return( -1 );
  1086.       }
  1087.    if ((fh2 = Fopen( destfile,0 )) > 0)
  1088.       {
  1089.       if (form_alert( 2,copywarn )==2)
  1090.          {
  1091.          Fclose( fh1 );
  1092.          Fclose( fh2 );
  1093.          CloseCBox();
  1094.          return( 0 );
  1095.          }
  1096.       else
  1097.          {
  1098.          Fclose( fh2 );
  1099.          fh2 = Fopen( destfile,1 );
  1100.          }
  1101.       }
  1102.    else
  1103.       fh2 = Fcreate( destfile,0 );
  1104.  
  1105.    graf_mouse( BUSY_BEE,0L );
  1106.    while ((lret = Fread( fh1,(LONG)BUFSIZE,buffer )) > 0L)
  1107.       Fwrite( fh2,lret,buffer );
  1108.    graf_mouse( ARROW,0L );
  1109.    Fclose( fh1 );
  1110.    Fclose( fh2 );
  1111.    CloseCBox();
  1112.    return( 0 );
  1113. }
  1114.  
  1115. WORD movefile( workfile )
  1116. BYTE workfile[];
  1117. {
  1118. BYTE destfile[ MAXSPEC ], buffer[ BUFSIZE ];
  1119. register WORD fh1, fh2;
  1120. register LONG lret;
  1121.  
  1122.    if ((DoCForm( workfile,destfile,2 ))||!strlen( destfile ))
  1123.       {
  1124.       CloseCBox();
  1125.       return(0);
  1126.       }
  1127.    if (strcmp( workfile,destfile )==0)
  1128.       {
  1129.       form_alert( 1,badcopy );
  1130.       CloseCBox();
  1131.       return( -1 );
  1132.       }
  1133.    if ((fh1 = Fopen( workfile,0 )) < 0)
  1134.       {
  1135.       form_alert( 1,filerr );
  1136.       CloseCBox();
  1137.       return( -1 );
  1138.       }
  1139.    if ((fh2 = Fopen( destfile,0 )) > 0)
  1140.       {
  1141.       form_alert( 1,movexist );
  1142.       Fclose( fh1 );
  1143.       Fclose( fh2 );
  1144.       CloseCBox();
  1145.       return(-1);
  1146.       }
  1147.    else
  1148.       if ((fh2 = Fcreate( destfile,0 )) < 0)
  1149.          {
  1150.          form_alert( 1,crerror );
  1151.          Fclose( fh1 );
  1152.          CloseCBox();
  1153.          return( -1 );
  1154.          }
  1155.  
  1156.    graf_mouse( BUSY_BEE,0L );
  1157.    while ((lret = Fread( fh1,(LONG)BUFSIZE,buffer )) > 0)
  1158.       while (Fwrite( fh2,lret,buffer ) < 0)
  1159.          if (form_alert( 1,badwrite ) == 2)
  1160.             {
  1161.             Fclose( fh1 );
  1162.             Fclose( fh2 );
  1163.             CloseCBox();
  1164.             graf_mouse( ARROW,0L );
  1165.             return( -1 );
  1166.             }
  1167.    Fclose( fh1 );
  1168.    Fclose( fh2 );
  1169.    Fdelete( workfile );
  1170.    CloseCBox();
  1171.    graf_mouse( ARROW,0L );
  1172.    strcpy( workfile,destfile );
  1173.    return( 0 );
  1174. }
  1175. WORD printfile( workfile )
  1176. BYTE workfile[];
  1177. {
  1178. BYTE buffer[ BUFSIZE ];
  1179. register WORD fh1, i;
  1180. register LONG lret;
  1181.  
  1182.    while (Cprnos()==0L)
  1183.       if (form_alert( 2,prnerror )==2)
  1184.          return(-1);
  1185.    if ((fh1 = Fopen( workfile,0 )) < 0)
  1186.       {
  1187.       form_alert( 1,filerr );
  1188.       return( -1 );
  1189.       }
  1190.    graf_mouse( BUSY_BEE,0L );
  1191.    while ((lret = Fread( fh1,(LONG)BUFSIZE,buffer )) > 0)
  1192.       for (i=0; i<(WORD)lret; i++)
  1193.          if (Cprnout( buffer[ i ] )==0)
  1194.             if (form_alert( 1,prnerror )==2)
  1195.                {
  1196.                Fclose( fh1 );
  1197.                graf_mouse( ARROW,0L );
  1198.                return( -1 );
  1199.                }
  1200.    Fclose( fh1 );
  1201.    graf_mouse( ARROW,0L );
  1202.    return( 0 );
  1203. }
  1204.  
  1205. WORD delfile( workfile )
  1206. BYTE workfile[];
  1207. {
  1208.    if (form_alert( 2,suredel )==1)
  1209.       {
  1210.       if ((WORD)Fdelete( workfile ))
  1211.          {
  1212.          form_alert( 1,delerror );
  1213.          return( -1 );
  1214.          }
  1215.       }
  1216.    else
  1217.       return(-1);
  1218.    return( 0 );
  1219. }
  1220.  
  1221. WORD renamefile( workfile )
  1222. BYTE workfile[];
  1223. {
  1224. BYTE destfile[ MAXSPEC ];
  1225.  
  1226.    if ((DoCForm( workfile,destfile,0 ))||!strlen( destfile ))
  1227.       {
  1228.       CloseCBox();
  1229.       return(0);
  1230.       }
  1231.    if (Frename( 0,workfile,destfile ) < 0)
  1232.       {
  1233.       form_alert( 1,badrename );
  1234.       CloseCBox();
  1235.       return( -1 );
  1236.       }
  1237.    else
  1238.       {
  1239.       strcpy( workfile,destfile );
  1240.       CloseCBox();
  1241.       return( 0 );
  1242.       }
  1243. }
  1244.  
  1245. /* ---------- ValidSpec() -- validate an input file specification ---- */
  1246.  
  1247. WORD ValidSpec( filespec )
  1248. BYTE *filespec;
  1249. {
  1250. register WORD len = strlen( filespec ), i, partlen = 0, error = 0;
  1251. register WORD wild = FALSE;
  1252. WORD inname = TRUE, inext = FALSE;
  1253.  
  1254.    /* empty filespecs are not valid for our purposes */
  1255.    if (!len)
  1256.       return( FALSE );
  1257.    /* Determine the search string and drive */
  1258.    cur_drv = -1;
  1259.    for (i=SDRIVEA; i<SDRIVEA+15; i++)
  1260.       if (s_form[ i ].ob_state & SELECTED)
  1261.          {
  1262.          cur_drv = i-SDRIVEA;
  1263.          drv_let = cur_drv + 'A';
  1264.          break;
  1265.          }
  1266.    if (filespec[1] == ':')       /* drive specified in filespec */
  1267.       {
  1268.       if (cur_drv != -1)
  1269.          s_form[ SDRIVEA+cur_drv ].ob_state &= ~SELECTED;
  1270.       drv_let = toupper(filespec[0]);
  1271.       cur_drv = drv_let - 'A';
  1272.       if (s_form[ SDRIVEA+cur_drv ].ob_state & DISABLED)
  1273.          {
  1274.          form_alert( 1,baddrive );
  1275.          return(FALSE);
  1276.          }
  1277.       else
  1278.          s_form[ SDRIVEA+cur_drv ].ob_state |= SELECTED;
  1279.       if (strlen(filespec)==2)   /* cases like "B:" */
  1280.          strcat( filespec,"\*.*" );
  1281.       len = strlen( filespec )-1;
  1282.       memmove( filespec,&(filespec[2]),len );
  1283.       len = strlen( filespec );
  1284.       }
  1285.    /* Check for invalid charcters in the filespec */
  1286.    if (strpbrk( filespec,"!@#$%^&()-=+~`;:\"'<>{}[] " ) != NULL)
  1287.       {
  1288.       form_alert( 1,badspec );
  1289.       return( FALSE );
  1290.       }
  1291.    /* Check the filespec character by character */
  1292.    for (i=0; i<len && !error; i++)
  1293.       switch( filespec[i] )
  1294.          {
  1295.          case '\\':
  1296.             inname = TRUE;
  1297.             inext = FALSE;
  1298.             if (wild)
  1299.                {
  1300.                form_alert( 1,badwild );
  1301.                return( FALSE );
  1302.                }
  1303.             wild = FALSE;
  1304.             partlen = 0;
  1305.             break;
  1306.          case '.':
  1307.             inname = FALSE;
  1308.             inext = TRUE;
  1309.             wild = FALSE;
  1310.             partlen = 0;
  1311.             break;
  1312.          case '*':
  1313.             wild = TRUE;
  1314.             break;
  1315.          case '?':
  1316.             wild = TRUE;         /* and go on to next case */
  1317.          default:
  1318.             if (filespec[i] < 32 || filespec[i] > 127)
  1319.                error = 1;
  1320.             partlen++;
  1321.             if (partlen > 8 && inname)
  1322.                error = 2;
  1323.             if (partlen > 3 && inext)
  1324.                error = 3;
  1325.             break;
  1326.          }
  1327.    /* was an error found? */
  1328.    switch( error )
  1329.       {
  1330.       case 1:  form_alert( 1,badspec );
  1331.                return( FALSE );
  1332.       case 2:  form_alert( 1,badname );
  1333.                return( FALSE );
  1334.       case 3:  form_alert( 1,badext );
  1335.                return( FALSE );
  1336.       case 0:
  1337.       default: break;
  1338.       }
  1339.  
  1340.    /* See if a path is part of the filespec */
  1341.    for (i=len-1; i; i--)
  1342.       if (filespec[ i ] == '\\')
  1343.          break;
  1344.    last_path = i;
  1345.    if (last_path && filespec[0] != '\\')
  1346.       {
  1347.       memmove( filespec+1,filespec,++len );
  1348.       filespec[0] = '\\';
  1349.       }
  1350.    return( TRUE );
  1351. }
  1352.  
  1353. /* FinishFile() insures that a file name includes the drive and path.
  1354.    This routine assumes that filename[] is long enough to hold a 
  1355.    complete filespec */
  1356. WORD FinishFile( filename )
  1357. BYTE filename[];
  1358. {
  1359. BYTE newfile[ MAXSPEC+1 ], temp[ MAXSPEC+1 ];
  1360. WORD drive;
  1361.  
  1362.    newfile[0]='\0';
  1363.    drive = Dgetdrv();
  1364.    if (filename[1] != ':')
  1365.       {
  1366.       newfile[0]=drive+'A';
  1367.       newfile[1]=':';   
  1368.       newfile[2]='\0';
  1369.       }
  1370.    strcat( newfile,filename );
  1371.    if (newfile[2] != '\\')
  1372.       {
  1373.       Dgetpath( temp,drive+1 );   
  1374.       strcat( temp,"\\" );
  1375.       sprintf( filename,"%.2s%s%s",newfile,temp,newfile+2 );
  1376.       }
  1377.    else
  1378.       strcpy( filename,newfile );
  1379. }
  1380.  
  1381. /* FmtTime() -- formats time into string in hh:mm:ss format */
  1382. void FmtTime( f_time,l_buf )
  1383. WORD f_time;
  1384. BYTE l_buf[];
  1385. {
  1386. register unsigned WORD h,m;
  1387. BYTE m_buf[ 3 ];
  1388.  
  1389.    h = (f_time >> 11) & 0x001f;
  1390.    m = (f_time & 0x07e0) >> 5;
  1391.    if (h > 12)
  1392.       {
  1393.       h -= 12;
  1394.       strcpy( m_buf,"pm" );
  1395.       }
  1396.    else
  1397.       strcpy( m_buf,"am" );
  1398.    if (h == 0)
  1399.       h = 12;
  1400.    sprintf( l_buf,"%2u:%2u",h,m );
  1401.    if (m<10)
  1402.       l_buf[3] = '0';
  1403.    strcat( l_buf,m_buf );
  1404. }
  1405.  
  1406. /* FmtDate() -- formats a date into a string in mm/dd/yy format */
  1407. void FmtDate( f_date,l_buf )
  1408. WORD f_date;
  1409. BYTE l_buf[];
  1410. {
  1411. register unsigned WORD y,m,d;
  1412.  
  1413.    y = ((f_date >> 9) & 0x007f) + 80;
  1414.    if (y>100)
  1415.       y -= 100;
  1416.    m = (f_date & 0x01e0) >> 5;
  1417.    d = (f_date & 0x001f);
  1418.  
  1419.    sprintf( l_buf,"%2u-%2u-%2u",m,d,y );
  1420.    if (d<10)
  1421.       l_buf[3] = '0';
  1422.    if (y<10)
  1423.       l_buf[6] = '0';
  1424. }
  1425.  
  1426. /* ---------------------------------------------------------------------- */
  1427. /* Browse() has two purposes -- to browse a file and to browse the list   */ 
  1428. /* of files found in the last search.                                     */
  1429. /* When the argument type = 1, the filespec is of the file to be browsed. */
  1430. /* Otherwise, we are to browse the list of found files and filespec is    */
  1431. /* the search specification.                                              */
  1432. /* ---------------------------------------------------------------------- */
  1433. WORD Browse( filespec,type )
  1434. BYTE filespec[];
  1435. WORD type;
  1436. {
  1437. WORD dmy, xt, x, y, w, h, wind_type, top_window, ret;
  1438. WORD event, clik_x, clik_y, num_cliks, bstate, kstate, keycode;
  1439. WORD x_wk,y_wk,w_wk,h_wk,bmsgbuf[ 8 ];
  1440. register WORD sel = NOT_SELECTED, oldsel = NOT_SELECTED, w_hand;
  1441. GRECT box;
  1442.  
  1443. /* Set up text alignment */
  1444.    vst_alignment( handle,0,3,&dmy,&dmy );
  1445.  
  1446. /* Calculate working area for window based on size it'll be opened as */
  1447.    if (type)
  1448.       wind_type = WTYPE;
  1449.    else
  1450.       wind_type = BWTYPE;
  1451.    wind_calc(1,wind_type,WINX,WINY,(OUTWIDTH*cwidth),(NUMLINES*cheight),
  1452.                 &x_wk,&y_wk,&w_wk,&h_wk);
  1453.  
  1454. /* Create window */
  1455.    w_hand = wind_create( wind_type,x_mx,y_mx,w_mx,h_mx );
  1456.    if (w_hand < 0)
  1457.       {
  1458.       form_alert(1,no_windows);
  1459.       return( -1 );
  1460.       }
  1461.  
  1462. /* If this is a browse on a file, get that file */
  1463.    if (type)
  1464.       {
  1465.       /* Put up the "loading..." form */
  1466.       StartForm( l_form,&box,2,0,1 );
  1467.  
  1468.       /* load the file into the window */
  1469.       num_lines = LoadFile( filespec,&box );
  1470.       form_dial( FMD_FINISH,0,0,0,0,box.g_x,box.g_y,box.g_w,box.g_h );
  1471.       if (num_lines == -1)
  1472.          {
  1473.          /* clean up stuff allocated for browse function */
  1474.          wind_delete( w_hand );
  1475.          ReDraw( bw_handle,bx_wk,by_wk,bw_wk,bh_wk,type );
  1476.          return( -1 );
  1477.          }
  1478.       strcpy( wind_name,filespec );
  1479.       wind_set( w_hand,2,wind_name,0,0 );
  1480.       sprintf( wind_desc,"Total Lines In Window: %d", num_lines );
  1481.       wind_set( w_hand,3,wind_desc,0,0 );    
  1482.       }
  1483.    else
  1484.       {
  1485.       num_lines = filez;
  1486.       sprintf( wind_name,"Search string: %s",filespec );
  1487.       wind_set( w_hand,2,wind_name,0,0 );
  1488.       sprintf( wind_desc,"Files Found: %d",num_lines );
  1489.       wind_set( w_hand,3,wind_desc,0,0 );    
  1490.       }
  1491.  
  1492.    /* Open window and initialize window variables */
  1493.    l_start = 0;
  1494.    CalcRange( h_wk );
  1495.    slidpos = 1;
  1496.    SetSlidSize( w_hand );
  1497.    graf_growbox( x_mx,y_mx,cwidth,cheight,
  1498.                  WINX,WINY,(OUTWIDTH*cwidth),(NUMLINES*cheight) );
  1499.    wind_open( w_hand,WINX,WINY,(OUTWIDTH*cwidth),(NUMLINES*cheight) );
  1500.    browsing = TRUE;
  1501.  
  1502.    /* Handle events for this window until it is closed */
  1503.    do
  1504.       {
  1505.       event = evnt_multi(MU_MESAG|MU_BUTTON,2,3,1,
  1506.                          0,0,0,0,0,
  1507.                          0,0,0,0,0,
  1508.                          bmsgbuf,0,0,
  1509.                          &clik_x,&clik_y,&bstate,
  1510.                          &kstate,&keycode,&num_cliks );   
  1511.  
  1512.       /* Did the user select a file from the list? */
  1513.       if ((event & MU_BUTTON)&&!type)
  1514.          {
  1515.          wind_get( w_hand,WF_TOP,&top_window,&ret,&ret,&ret,&ret );
  1516.          if ((w_hand == top_window)&&(clik_x >= x_wk)&&
  1517.              (clik_y >= y_wk)&&(clik_x <= w_wk+x_wk)
  1518.              &&(clik_y <= h_wk+y_wk))
  1519.             {
  1520.             sel = (clik_y - y_wk + l_start*cheight)/cheight;
  1521.             if (sel != oldsel)
  1522.                {
  1523.                DeSelect( x_wk,y_wk,w_wk,h_wk,oldsel );
  1524.                oldsel = sel;
  1525.                Select( x_wk,y_wk,w_wk,h_wk,sel );
  1526.                }
  1527.             if (num_cliks == 2)
  1528.                if (sel >= 0 && sel < num_lines)
  1529.                   DoFile( sel );
  1530.             }
  1531.          else
  1532.             {
  1533.             DeSelect( x_wk,y_wk,w_wk,h_wk,oldsel );
  1534.             sel = oldsel = NOT_SELECTED;
  1535.             }
  1536.          }           
  1537.  
  1538.       /* Message event */
  1539.       if (event & MU_MESAG)  
  1540.          {
  1541.          /* If a window event was received for one of ours, handle it */
  1542.          if (bmsgbuf[3]==bw_handle)
  1543.             if (bmsgbuf[0]==WM_REDRAW)
  1544.                {
  1545.                ReDraw( bmsgbuf[3],bx_wk,by_wk,bw_wk,bh_wk,type );
  1546.                }
  1547.          if (bmsgbuf[3]==w_hand)
  1548.             {
  1549.             /* Handle all window messages */
  1550.             switch (bmsgbuf[0])
  1551.                {
  1552.                case WM_TOPPED:
  1553.                case WM_NEWTOP:
  1554.                   wind_set(bmsgbuf[3],WF_TOP,0,0,0,0 );
  1555.                   break;
  1556.                case WM_ARROWED:
  1557.                   switch (bmsgbuf[4])
  1558.                      {
  1559.                      case 0:   /* page up */
  1560.                         l_start -= page_size;;
  1561.                         l_end -= page_size;
  1562.                         break;
  1563.                      case 1:   /* page down */
  1564.                         l_start += page_size;;
  1565.                         l_end += page_size;
  1566.                         break;
  1567.                      case 2:   /* up arrow */
  1568.                         l_start--;
  1569.                         l_end--;
  1570.                         break;
  1571.                      case 3:   /* down arrow */
  1572.                         l_start++;
  1573.                         l_end++;
  1574.                         break;
  1575.                      }  /* end switch */
  1576.                   if (l_start < 0)
  1577.                      l_start = 0;
  1578.                   if (l_start > num_lines)
  1579.                      l_start = num_lines;
  1580.                   if (l_end < 0)
  1581.                      l_end = 0;
  1582.                   if (l_end > num_lines)
  1583.                      l_end = num_lines;
  1584.                   if (l_end == num_lines)
  1585.                      l_start = l_end - l_range;
  1586.                   l_end = l_start + l_range;
  1587.                   newslid = CalcSlidPos();
  1588.                   if (newslid != slidpos)
  1589.                      {
  1590.                      slidpos = newslid;
  1591.                      wind_set( bmsgbuf[3],WF_VSLIDE,slidpos,0,0,0 );
  1592.                      switch( bmsgbuf[ 4 ] )
  1593.                         {
  1594.                         case 0:
  1595.                         case 1:
  1596.                            ReDraw( bmsgbuf[3],x_wk,y_wk,w_wk,h_wk,type );
  1597.                            break;
  1598.                         case 2:
  1599.                            LineDown(x_wk,y_wk,w_wk,h_wk);
  1600.                            break;
  1601.                         case 3:
  1602.                            LineUp(x_wk,y_wk,w_wk,h_wk);
  1603.                            break;
  1604.                         default:
  1605.                            break;
  1606.                         }     /* end switch */
  1607.                      }
  1608.                   break;
  1609.                case WM_VSLID:
  1610.                   if (bmsgbuf[4] != slidpos)
  1611.                      {
  1612.                      slidpos = bmsgbuf[4];
  1613.                      wind_set( bmsgbuf[3],WF_VSLIDE,slidpos,0,0,0 );
  1614.                      CalcStart();
  1615.                      ReDraw( bmsgbuf[3],x_wk,y_wk,w_wk,h_wk,type );
  1616.                      }
  1617.                   break;
  1618.                case WM_SIZED:
  1619.                case WM_MOVED:
  1620.                   if ((xt=w_wk) < gr_w)
  1621.                      {
  1622.                      w_wk = gr_w;
  1623.                      bmsgbuf[6] += gr_w - xt;
  1624.                      } 
  1625.                   if((xt=h_wk) < gr_h)
  1626.                      {
  1627.                      h_wk = gr_h;
  1628.                      bmsgbuf[7] += gr_h - xt;
  1629.                      }
  1630.                   wind_set(w_hand,WF_CURRXYWH,bmsgbuf[4],bmsgbuf[5],
  1631.                            bmsgbuf[6],bmsgbuf[7]);
  1632.                   wind_calc(1,wind_type,bmsgbuf[4],bmsgbuf[5],bmsgbuf[6],
  1633.                             bmsgbuf[7],&x_wk,&y_wk,&w_wk,&h_wk);
  1634.                   wind_set(w_hand,WF_WORKXYWH,x_wk,
  1635.                            y_wk,w_wk,h_wk);
  1636.                   CalcRange( h_wk );
  1637.                   SetSlidSize( w_hand );
  1638.                   break;
  1639.                case WM_REDRAW:
  1640.                   ReDraw( bmsgbuf[3],x_wk,y_wk,w_wk,h_wk,type );
  1641.                   break;
  1642.                case WM_FULLED:
  1643.                   wind_get( w_hand,WF_CURRXYWH,&x,&y,&w,&h );
  1644.                   if (w==w_mx && h==h_mx)
  1645.                      {
  1646.                      wind_get( w_hand,WF_PREVXYWH,&x,&y,&w,&h );
  1647.                      wind_set( w_hand,WF_CURRXYWH,x,y,w,h );
  1648.                      wind_calc(1,wind_type,x,y,w,h,
  1649.                                &x_wk,&y_wk,&w_wk,&h_wk);
  1650.                      wind_set( w_hand,WF_WORKXYWH,x_wk,
  1651.                                y_wk,w_wk,h_wk );
  1652.                      }
  1653.                   else
  1654.                      {
  1655.                      wind_set( w_hand,WF_CURRXYWH,x_mx,
  1656.                                y_mx,w_mx,h_mx );
  1657.                      wind_calc(1,wind_type,x_mx,y_mx,
  1658.                                w_mx,h_mx,&x_wk,&y_wk,&w_wk,&h_wk);
  1659.                      wind_set( w_hand,WF_WORKXYWH,x_wk,
  1660.                                y_wk,w_wk,h_wk );
  1661.                      }
  1662.                   CalcRange( h_wk );
  1663.                   SetSlidSize( w_hand );
  1664.                   break;
  1665.                case WM_CLOSED:
  1666.                   wind_close( bmsgbuf[3] );
  1667.                   graf_shrinkbox( x_wk+w_wk/2,y_wk+h_wk/2,cwidth,cheight,
  1668.                                   x_wk,y_wk,w_wk,h_wk );
  1669.                   /* clean up stuff allocated for browse function */
  1670.                   FreeHeap();
  1671.                   wind_delete( w_hand );
  1672.                   browsing = FALSE;
  1673.                   ReDraw( bw_handle,bx_wk,by_wk,bw_wk,bh_wk,type );
  1674.                   break;
  1675.                default:
  1676.                   break;
  1677.                }  /* end switch */
  1678.             }  /* end, if a message received */
  1679.          }  /* end, if it was for our browse window */
  1680.       } while (browsing);
  1681.    return( 0 );
  1682. }
  1683.  
  1684. /* ---------- Window update functions -------------------------------- */
  1685.  
  1686. void SetSlidSize( w_hand )
  1687. WORD w_hand;
  1688. {
  1689.    slidsize = (WORD)((l_range*999L)/num_lines + 1);
  1690.    wind_set( w_hand,WF_VSLSIZE,slidsize,0,0,0 );
  1691. }
  1692.  
  1693. void CalcRange( rh )
  1694. WORD rh;
  1695. {
  1696.    l_range = (WORD)(rh/cheight);
  1697.    if (l_range > num_lines)
  1698.       {
  1699.       l_start = 0;
  1700.       l_range = num_lines;
  1701.       }
  1702.    l_end = l_start + l_range;
  1703.    if (l_end > num_lines)
  1704.       {
  1705.       l_end = num_lines;
  1706.       l_start = l_end - l_range;
  1707.       }
  1708.    page_size = l_range;
  1709. }
  1710.  
  1711. void CalcStart()
  1712. {
  1713.    l_start = (WORD)(slidpos*(LONG)(num_lines-l_range)/1000L);
  1714.    l_end = l_start + l_range;
  1715.    if (l_end > num_lines)
  1716.       l_end = num_lines;
  1717. }
  1718.  
  1719. WORD CalcSlidPos()
  1720. {
  1721.    return( (WORD)((l_start*999L)/(num_lines+l_start-l_end)) + 1);
  1722. }
  1723.  
  1724. WORD ReDraw( w_handle,rl,rt,rw,rh,type )
  1725. WORD w_handle;             /* window to redraw */
  1726. WORD rl,rt,rw,rh;          /* rectangle extent */
  1727. WORD type;                 /* 1 if file text, 0 if file list */
  1728. {
  1729. WORD wl, wt, ww, wh;    /* window extent */
  1730. WORD clip[4];
  1731.  
  1732.    wind_update( TRUE );
  1733.    graf_mouse( M_OFF,0 );
  1734.    wind_get( w_handle,WF_FIRSTXYWH,&wl,&wt,&ww,&wh );
  1735.    while (ww && wh)
  1736.       {      /* do the rectangles intersect? */
  1737.       if (rl < wl+ww && wl < rl+rw && rt < wt+wh && wt < rt+rh)
  1738.          {
  1739.          /* Set clipping area for rectangle to be redrawn */
  1740.          clip[0] = wl;
  1741.          clip[2] = wl + ww - 1;
  1742.          clip[1] = wt;
  1743.          clip[3] = wt + wh - 1;
  1744.          vs_clip( handle,1,clip );
  1745.          /* Clear the area, first, with a solid filled rectangle */
  1746.          vsf_interior(handle,2);
  1747.          vsf_style(handle,8);
  1748.          vsf_color(handle,0);
  1749.          v_bar(handle,clip);
  1750.          /* Update the area appropriately */
  1751.          if (w_handle == bw_handle)
  1752.             RefrBackground( rl,rt,rw,rh );
  1753.          else
  1754.             {
  1755.             if (type)
  1756.                RefrText( rl,rt );
  1757.             else
  1758.                RefrList( rl,rt );
  1759.             }
  1760.          }  /* end if */
  1761.       wind_get( w_handle,WF_NEXTXYWH,&wl,&wt,&ww,&wh);
  1762.       }  /* end while */
  1763.    graf_mouse( M_ON,0 );
  1764.    wind_update( FALSE );
  1765.    vs_clip( handle,0,clip );
  1766. } /* end redraw */
  1767.  
  1768. WORD RefrText( rl,rt )
  1769. WORD rl,rt;
  1770. {
  1771. register WORD i, x, y;
  1772.  
  1773.    for (i=l_start; i<l_end; i++)
  1774.       {
  1775.       x = (WORD)(rl+cwidth/2);
  1776.       y = (WORD)(rt+cheight*(i-l_start)+cheight);
  1777.       vswr_mode(handle,1);          /* replace mode */
  1778.       v_gtext( handle,x,y,pagetext[i] );
  1779.       }
  1780. }
  1781.  
  1782. WORD RefrEntry( rl,rt,rw,rh,lin,selflag )
  1783. WORD rl,rt,rw,rh,lin,selflag;
  1784. {
  1785. WORD clip[4];
  1786. register WORD i, x, y;
  1787. register FL *next;
  1788.  
  1789.    /* find the entry */
  1790.    next = list_head;
  1791.    for (i=0; i<lin; i++)
  1792.       {
  1793.       if (next == NULL)
  1794.          return( -1 );
  1795.       next = next->next;
  1796.       }
  1797.    /* Set clipping area */
  1798.    clip[0] = rl;
  1799.    clip[2] = rl + rw - 1;
  1800.    clip[1] = rt;
  1801.    clip[3] = rt + rh - 1;
  1802.    vs_clip( handle,1,clip );
  1803.    /* Refresh the entry */
  1804.    x = (WORD)(rl+cwidth/2);
  1805.    y = (WORD)(rt+cheight*(i-l_start)+cheight);
  1806.    /* Display the file name in the appropriate display mode */
  1807.    if (selflag)
  1808.       {
  1809.       vswr_mode(handle,3);          /* XOR mode, to blank out */
  1810.       v_gtext( handle,x,y,next->spec );
  1811.       vswr_mode(handle,4);          /* reverse transparent mode */
  1812.       v_gtext( handle,x,y,next->spec );
  1813.       vswr_mode(handle,1);          /* replace mode */
  1814.       }
  1815.    else
  1816.       {
  1817.       vswr_mode(handle,1);          /* replace mode */
  1818.       v_gtext( handle,x,y,next->spec );
  1819.       }
  1820.    vs_clip( handle,1,clip );
  1821.    return(0);
  1822. }
  1823.  
  1824. WORD RefrList( rl,rt )
  1825. WORD rl,rt;
  1826. {
  1827. register WORD i, x, y;
  1828. register FL *next;
  1829.  
  1830.    next = list_head;
  1831.    for (i=0; i<l_start; i++)
  1832.       {
  1833.       if (next == NULL)
  1834.          return( -1 );
  1835.       next = next->next;
  1836.       }
  1837.    for (i=l_start; i<l_end; i++)
  1838.       {
  1839.       if (next == NULL)
  1840.          return( -1 );
  1841.       x = (WORD)(rl+cwidth/2);
  1842.       y = (WORD)(rt+cheight*(i-l_start)+cheight);
  1843.       vswr_mode(handle,1);          /* replace mode */
  1844.       v_gtext( handle,x,y,next->spec );
  1845.       next = next->next;
  1846.       }
  1847.    return(0);
  1848. }
  1849.  
  1850. WORD RefrBackground( rl,rt,rw,rh )
  1851. WORD rl,rt,rw,rh;
  1852. {
  1853. WORD clip[ 4 ];
  1854.  
  1855.    clip[0] = rl;     clip[1] = rt;
  1856.    clip[2] = rl + rw - 1;
  1857.    clip[3] = rt + rh - 1;
  1858.    vsf_interior( handle,2 );
  1859.    vsf_style( handle,8 );
  1860.    vsf_color( handle,back_color );
  1861.    v_bar( handle,clip );
  1862. }
  1863.  
  1864. WORD RefrLine( rl,rt,rw,rh,lin )
  1865. WORD rl,rt,rw,rh,lin;
  1866. {
  1867. register WORD x, y, plin;
  1868. WORD clip[4];
  1869.  
  1870.    wind_update( TRUE );
  1871.    graf_mouse( M_OFF,0 );
  1872.    /* Set clipping area */
  1873.    clip[0] = rl;
  1874.    clip[2] = rl + rw - 1;
  1875.    clip[1] = rt;
  1876.    clip[3] = rt + rh - 1;
  1877.    vs_clip( handle,1,clip );
  1878.    /* If line is on screen, rewrite it */
  1879.    if ((lin >= l_start)&&(lin < l_end))
  1880.       {
  1881.       x = (WORD)(rl+cwidth/2);
  1882.       y = (WORD)(rt+cheight*(lin-l_start)+cheight);
  1883.       /* Clear the area, first, with a solid filled rectangle */
  1884.       clip[0] = rl;
  1885.       clip[1] = (WORD)(rt+cheight*(lin-l_start));
  1886.       clip[2] = rl + rw - 1;
  1887.       clip[3] = clip[1] + cheight - 1;
  1888.       vsf_interior( handle,2 );
  1889.       vsf_style( handle,8 );
  1890.       vsf_color( handle,0 );
  1891.       v_bar( handle,clip );
  1892.       vswr_mode( handle,1 );           /* replace mode */
  1893.       plin = lin-1;
  1894.       if ((plin >= l_start)&&(plin < l_end))
  1895.          v_gtext( handle,x,y-cheight,pagetext[ lin-1 ] );
  1896.       v_gtext( handle,x,y,pagetext[ lin ] );
  1897.       }
  1898.    /* clean up */
  1899.    graf_mouse( M_ON,0 );
  1900.    wind_update( FALSE );
  1901.    vs_clip( handle,0,clip );
  1902. }
  1903.  
  1904. /* LineUp() and LineDown() move screen memory to accomplish
  1905.    smooth scrolling within the BROWSE window */
  1906. void LineUp( rl,rt,rw,rh )
  1907. WORD rl,rt,rw,rh;
  1908. {
  1909. WORD array[ 8 ];
  1910.  
  1911.    array[0] = array[4] = rl;
  1912.    array[1] = rt + cheight;
  1913.    array[2] = array[6] = rl + rw - 1;
  1914.    array[3] = rt + rh - 1;
  1915.    array[5] = rt;
  1916.    array[7] = rt + rh - cheight - 1;
  1917.    vro_cpyfm( handle,S_ONLY,array,mfdb,mfdb );
  1918.    RefrLine( rl,rt,rw,rh,l_end-1 );
  1919. }
  1920.  
  1921. void LineDown( rl,rt,rw,rh )
  1922. WORD rl,rt,rw,rh;
  1923. {
  1924. WORD array[ 8 ];
  1925.  
  1926.    array[0] = array[4] = rl;
  1927.    array[1] = rt;
  1928.    array[2] = array[6] = rl + rw - 1;
  1929.    array[3] = rt + rh - cheight - 1;
  1930.    array[5] = rl + cheight;
  1931.    array[7] = rt + rh - 1;
  1932.    vro_cpyfm( handle,S_ONLY,array,mfdb,mfdb );
  1933.    RefrLine( rl,rt,rw,rh,l_start );
  1934. }
  1935.  
  1936. /* Select and DeSelect work on a line of text within the BROWSE window */
  1937. void Select( rx,ry,rw,rh,lin )
  1938. WORD rx,ry,rw,rh,lin;
  1939. {
  1940.    if (lin != NOT_SELECTED && lin >= l_start && lin < l_end)
  1941.       {
  1942.       graf_mouse( M_OFF,0L );
  1943.       RefrEntry( rx,ry,rw,rh,lin,1 );
  1944.       graf_mouse( M_ON,0L );
  1945.       }
  1946. }
  1947.  
  1948. void DeSelect( rx,ry,rw,rh,lin )
  1949. WORD rx,ry,rw,rh,lin;
  1950. {
  1951.    if (lin != NOT_SELECTED && lin >= l_start && lin < l_end)
  1952.       {
  1953.       graf_mouse( M_OFF,0L );
  1954.       RefrEntry( rx,ry,rw,rh,lin,0 );
  1955.       graf_mouse( M_ON,0L );
  1956.       }
  1957. }
  1958.  
  1959. /* PrintList() prints the list of found files.  It invokes PrintLine()
  1960.    for each line of text.  The lines are sent to the parallel port.
  1961. */
  1962. WORD PrintList()
  1963. {
  1964. BYTE line[ LINEWIDTH+1 ], dbuff[ 11 ], tbuff[ 11 ];
  1965. register FL *next;
  1966.  
  1967.    /* Check the printer status */
  1968.    while (Cprnos()==0L)
  1969.       if (form_alert( 2,prnerror )==2)
  1970.          return(-1);
  1971.    next = list_head;
  1972.    /* Print some header information */
  1973.    sprintf( line,"Search string: %s\n",filespec );
  1974.    if (PrintLine( line )==-1)
  1975.       return( -1 );
  1976.    /* Print each file in the list */
  1977.    while (next != NULL)
  1978.       {
  1979.       FmtDate( next->date,dbuff );
  1980.       FmtTime( next->time,tbuff );
  1981.       sprintf( line,"%s\n",next->spec );
  1982.       if (PrintLine( line )==-1)
  1983.          return( -1 );
  1984.       sprintf( line,"   %lu %s %s\n",next->size,dbuff,tbuff );
  1985.       if (PrintLine( line )==-1)
  1986.          return( -1 );
  1987.       next = next->next;
  1988.       }
  1989.    return( 0 );
  1990. }
  1991.  
  1992. WORD PrintLine( line )
  1993. BYTE line[];
  1994. {
  1995. register WORD i, len;
  1996.  
  1997.    len = strlen( line );
  1998.    for (i=0; i<len; i++)
  1999.       if (Cprnout( line[i] )==0)
  2000.          if (form_alert( 1,prnerror )==2)
  2001.             return( -1 );
  2002.    return( 0 );
  2003. }
  2004.  
  2005. /* --------------------------------------------------------------- */
  2006. /* LoadFile() loads a file into the Browse window.                 */
  2007. /* --------------------------------------------------------------- */
  2008. WORD LoadFile( filespec,dims )
  2009. BYTE filespec[];
  2010. GRECT *dims;
  2011. {
  2012. BYTE filebuff[ BUFSIZE+1 ], linebuff[ LINEWIDTH+1 ];
  2013. WORD index = 0, box[ 4 ], linelen = 0, fhandle;
  2014. WORD bpx, lstart = 0;
  2015. register WORD bread,inline,fstart,togo = 0,last_read = 0;
  2016.  
  2017.    /* Get all available memory for our "heap" */
  2018.    if (GetHeap())
  2019.       {
  2020.       form_alert( 1,nomem );
  2021.       return( -1 );
  2022.       }
  2023.  
  2024.    /* Set up 'loading' box variables */
  2025.    bpx = (WORD)(dta.size/l_form[ LBOX ].ob_width) + 1;
  2026.    box[ 0 ] = box[ 2 ] = dims->g_x+l_form[ LBOX ].ob_x;
  2027.    box[ 1 ] = dims->g_y+l_form[ LBOX ].ob_y + 2;
  2028.    box[ 3 ] = box[ 1 ] + l_form[ LBOX ].ob_height + 1;
  2029.    box[ 2 ]++;
  2030.    vsf_style( handle,0 );
  2031.    vsf_color( handle,1 );
  2032.  
  2033.    /* Open the file for reading */
  2034.    graf_mouse( BUSY_BEE,0L );
  2035.    if ((fhandle = Fopen( filespec,0 )) < 0)
  2036.       {
  2037.       graf_mouse( ARROW,0L );
  2038.       form_alert( 1,filerr );
  2039.       FreeHeap();
  2040.       return(-1);
  2041.       }
  2042.  
  2043.    /* read the file into the up-to MAXLINES LINEWIDTH char lines */
  2044.    while ((bread = (WORD)Fread( fhandle,(LONG)BUFSIZE,filebuff )) > 0)
  2045.       {
  2046.       fstart = 0;
  2047.       togo = bread;
  2048.       /* if necessary, add to the "loading" box */
  2049.       last_read += bread;
  2050.       while (last_read > bpx)
  2051.          {
  2052.          last_read -= bpx;
  2053.          box[ 0 ] = box[ 2 ];
  2054.          box[ 2 ]++;
  2055.          v_bar( handle,box );
  2056.          }
  2057.       while (togo > 0)
  2058.          {
  2059.          inline = BufToLine( filebuff,linebuff,bread,LINEWIDTH,
  2060.                              fstart,&lstart );
  2061.          fstart += inline;
  2062.          togo -= inline;
  2063.          linelen += inline;
  2064.          /* If lstart=0, a line has been completed.  Add it to the buffer */
  2065.          if (!lstart)
  2066.             {
  2067.             if ((pagetext[ index ] = (BYTE *)DJMalloc( (LONG)linelen+1L ))
  2068.                  == NULL)
  2069.                {
  2070.                graf_mouse( ARROW,0L );
  2071.                sprintf( alert_box,
  2072.                         "[0][ ERROR:  Out Of Memory At | %d Lines.  ][ OK ]",
  2073.                         index );
  2074.                form_alert( 1,alert_box );
  2075.                FreeHeap();
  2076.                return(-1);
  2077.                }
  2078.  
  2079.             /* Copy the input buffer to the new line */
  2080.             strncpy( pagetext[ index ],linebuff,linelen );
  2081.             pagetext[ index ][ linelen ] = '\0';
  2082.             linelen = 0;
  2083.  
  2084.             /* If the maximum number of lines has been read, exit */
  2085.             if (++index >= MAXLINES-1)
  2086.                break;
  2087.             }
  2088.          }
  2089.       }
  2090.  
  2091.    /* Fill up the rest of the box */
  2092.    box[ 0 ] = dims->g_x+l_form[ LBOX ].ob_x;
  2093.    box[ 1 ] = dims->g_y+l_form[ LBOX ].ob_y + 2;
  2094.    box[ 2 ] = box[ 0 ] + l_form[ LBOX ].ob_width + 2;
  2095.    box[ 3 ] = box[ 1 ] + l_form[ LBOX ].ob_height + 1;
  2096.    vsf_style( handle,8 );
  2097.    vsf_color( handle,1 );
  2098.    v_bar( handle,box );
  2099.  
  2100.    /* Clean up and return number of lines read */
  2101.    Fclose( fhandle );
  2102.    graf_mouse( ARROW,0L );
  2103.    return( index );
  2104. }
  2105.  
  2106. /* --------------------------------------------------------------- */
  2107. /* BufToLine() moves the appropriate number of characters from     */
  2108. /* the file input buffer to a line buffer and updates all          */
  2109. /* counters as necessary                                           */
  2110. /* --------------------------------------------------------------- */
  2111. WORD BufToLine( filebuff,linebuff,fblen,maxline,fstart,lstart )
  2112. BYTE filebuff[],linebuff[];
  2113. WORD fblen, maxline, fstart, *lstart;
  2114. {
  2115. register WORD fidx, lidx, ret;
  2116.  
  2117.    for (fidx=fstart,lidx=*lstart; fidx<fblen && lidx<maxline; fidx++,lidx++)
  2118.       {
  2119.       if (filebuff[ fidx ] == '\n')
  2120.          {
  2121.          linebuff[ lidx ? lidx-1 : lidx ] = '\0';
  2122.          ret = lidx-*lstart;
  2123.          *lstart = 0;
  2124.          return( ret+1 );
  2125.          }
  2126.       linebuff[ lidx ] = filebuff[ fidx ];
  2127.       if ((linebuff[ lidx ] < 32)||(linebuff[ lidx ] > 127))
  2128.          linebuff[ lidx ] = ' ';
  2129.       }
  2130.    /* Determine how many characters were moved */
  2131.    ret = lidx - *lstart;
  2132.    /* Determine which limit was reached and handle accordingly */
  2133.    if (lidx == maxline)
  2134.       {
  2135.       linebuff[ lidx ] = '\0';
  2136.       *lstart = 0;
  2137.       return( ret );
  2138.       }
  2139.    if (fidx == fblen)
  2140.       *lstart = lidx;
  2141.    else
  2142.       *lstart = 0;
  2143.    return( ret+1 );
  2144. }
  2145.  
  2146. /* -------- Memory management for the list of files we've found ------ */
  2147.  
  2148. WORD AddList( dtaptr,filespec )
  2149. DTA *dtaptr;
  2150. BYTE *filespec;
  2151. {
  2152. register FL *new = NULL, *next = NULL, *prev = NULL;
  2153. BL *new_block = NULL;
  2154.  
  2155.    /* space for list members is allocated in blocks --
  2156.       see if some space is already available.  If not, allocate a block */
  2157.    if (!left_in_block)
  2158.       {
  2159.       if ((new_block = (BL *)Malloc( (LONG)sizeof( BL ) ))==NULL)
  2160.          return( -1 );
  2161.       new_block->next = NULL;
  2162.       if (cur_block != NULL)
  2163.          cur_block->next = new_block;
  2164.       cur_block = new_block;
  2165.       if ((next_file = (FL *)Malloc( (LONG)(ALLOCNUM*sizeof( FL )) ))==NULL)
  2166.          return( -1 );
  2167.       cur_block->first = next_file;
  2168.       left_in_block = ALLOCNUM;
  2169.       if (block_head == NULL)
  2170.          block_head = cur_block;
  2171.       }
  2172.  
  2173.    /* Get our next list member from the current block */
  2174.    if ((new = next_file) == NULL)
  2175.       return(-1);
  2176.    left_in_block--;
  2177.    next_file = (FL *)&(cur_block->first[ (ALLOCNUM-left_in_block) ]);
  2178.  
  2179.    /* Copy the data into the new member */
  2180.    strcpy( new->spec,filespec );
  2181.    new->size = dtaptr->size;
  2182.    new->date = dtaptr->date;
  2183.    new->time = dtaptr->time;
  2184.    new->attr = dtaptr->attr;
  2185.    new->next = NULL;
  2186.  
  2187.    /* Insert the new member into the list */
  2188.    if (list_head == NULL)
  2189.       {
  2190.       list_head = new;
  2191.       return( 0 );
  2192.       }
  2193.    next = list_head;
  2194.    while (next != NULL)
  2195.       {
  2196.       if (strcmp( next->spec,new->spec ) > 0)
  2197.          {
  2198.          new->next = next;
  2199.          if (prev == NULL)
  2200.             list_head = new;
  2201.          else
  2202.             prev->next = new;
  2203.          return( 0 );
  2204.          }
  2205.       prev = next;
  2206.       next = next->next;
  2207.       }
  2208.    prev->next = new;
  2209.    return( 0 );
  2210. }
  2211.  
  2212. void FreeBlocks()
  2213. {
  2214. register BL *next, *prev;
  2215.  
  2216.    next = block_head;
  2217.    while (next != NULL)
  2218.       {
  2219.       prev = next;
  2220.       Mfree( next );
  2221.       Mfree( next->first );
  2222.       next = prev->next;
  2223.       }
  2224.    block_head = NULL;
  2225.    cur_block = NULL;
  2226.    list_head = NULL;
  2227.    left_in_block = 0;
  2228. }
  2229.  
  2230. /* ---- Poor man's memory management functions --------------- */
  2231. /* ---- Used to set up and use memory for file Browse() ------ */
  2232. WORD GetHeap()
  2233. {
  2234.    heap_avail = Malloc( -1L );
  2235.    djheap = (BYTE *)Malloc( heap_avail );
  2236.    if (djheap == (BYTE *)NULL)
  2237.       return( -1 );
  2238.    else
  2239.       {
  2240.       heap_ptr = djheap;
  2241.       return( 0 );
  2242.       }
  2243. }
  2244.  
  2245. BYTE *DJMalloc( bytes )
  2246. LONG bytes;
  2247. {
  2248. register BYTE *curheap;
  2249.  
  2250.    if (bytes > heap_avail)
  2251.       return( NULL );
  2252.    curheap = heap_ptr;
  2253.    heap_ptr += bytes;
  2254.    heap_avail -= bytes;
  2255.    return( curheap );
  2256. }
  2257.  
  2258. void FreeHeap()
  2259. {
  2260.    Mfree( djheap );
  2261.    heap_avail = 0L;
  2262.    heap_ptr = NULL;
  2263. }
  2264.